/*#############################################################################
#    Copyright (C) 2008 by  Rene Alejandro Lobo Quintero raloboq@unal.edu.co, #
#    Julián Ricardo Mahecha D'Maria  jrmahechad@unal.edu.co,                  #
#    Diego Alejandro Montoya Cruz damontoyac@unal.edu.co                      #
#                                                                             #
#    This program is free software; you can redistribute it and#or modify     #
#    it under the terms of the GNU General Public License as published by     #
#    the Free Software Foundation; either version 2 of the License, or        #
#    (at your option) any later version.                                      #
#                                                                             #
#    This program is distributed in the hope that it will be useful,          #
#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
#    GNU General Public License for more details.                             #
#                                                                             #
#    You should have received a copy of the GNU General Public License        #
#    along with this program; if not, write to the                            #
#    Free Software Foundation, Inc.,                                          #
#    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.                #
#############################################################################*/

/*! \file rockola.cpp
  \class Rockola rockola.h
  *Este archivo lo que busca es crear toda la logica del programa y mostrar la informacion
  */
#include "rockola.h"
#include "ui_rockola.h"
#include <QTextStream>
#include <QFile>
#include <QMessageBox>

/*!
  * Funcion encargada de crear la ventana principal.
  */
Rockola::Rockola(QWidget *parent)
    : QMainWindow(parent), ui(new Ui::Rockola)
{
    ui->setupUi(this);
    superpath="/opt/SoLiUNToaster/";
    ui->VistaPrevia->setScaledContents(true);
}
/*!
  * Funcion encargada de borrar o destruir la ventana principal
  */
Rockola::~Rockola()
{
    delete ui;
}
/*!brief Funcion Boton Distribuciones
  *
  * Funcion encargada de pasar a la interfaz distros al hacer click en el boton distribuciones de la interfaz principal
  *
  */
void Rockola::on_B_Distribuciones_clicked()
{
    ui->stackedWidget->setCurrentIndex(1);
    find(1,"");

}
/*!\brief Funcion Boton Varios
  *
  * Funcion encargada de pasar a la interfaz contenidos varios (musica, libros, videos. imagenes) al hacer click en el boton varios de la interfaz principal
  * Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_Varios_clicked()
{
    ui->stackedWidget->setCurrentIndex(2);
    Limpiar();
    if(ui->RadioCD->isChecked())
    {
        peso=750*1024;
    }
    if(ui->RadioDVD->isChecked())
    {
        peso=4500*1024;
    }
    ui->EspacioDisco->setText(tr("%1").arg(peso/1024));
}
/*!\brief Funcion Varios-Libros
  *
  * Funcion encargada de mostrar los componentes nesesarios para que el usuario pueda escoger libros y agregarlos a la lista a quemar.
  * Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_Libros_clicked()
{
    ui->stackedVarios->setCurrentIndex(0);
    Limpiar();
}
/*!\brief Funcion Varios-Libros
  *
  * Funcion encargada de mostrar los componentes nesesarios para que el usuario pueda escoger musica y agregarla a la lista a quemar.
  * Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_Musica_2_clicked()
{
    ui->stackedVarios->setCurrentIndex(1);
    Limpiar();
}
/*!\brief Funcion Varios-Libros

   Funcion encargada de mostrar los componentes nesesarios para que el usuario pueda escoger imagenes y agregarlas a la lista a quemar.
   Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_Imagenes_2_clicked()
{
    ui->stackedVarios->setCurrentIndex(2);
    Limpiar();
}
/*!\brief Funcion Varios-Libros
  *
  * Funcion encargada de mostrar los componentes nesesarios para que el usuario pueda escoger peliculas y agregarlas a la lista a quemar.
  * Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_Peliculas_2_clicked()
{
    ui->stackedVarios->setCurrentIndex(3);
    Limpiar();
}
/*!\brief Funcion Distros-Atras
  *
  * Funcion encargada de regresar al usuario a la ventana principal, cuando este hace click en el boton atras de la interfaz distros
  * Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_AtrasDistros_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
    Limpiar();
}
/*!\brief Funcion Varios-Atras
  *
  * Funcion encargada de regresar al usuario a la ventana principal, cuando este hace click en el boton atras de la interfaz varios
  * Esta funcion llama a la funcion limpiar para reiniciar algunos de los componentes de la interfaz.
  */
void Rockola::on_B_AtrasVarios_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
    Limpiar();
    ui->ListaQuemar->clear();
}
/*! \brief Funcion encargada de buscar archivos en una carpeta especifica

  * Se tiene la ruta de la carpeta donde se va a buscar en una variable, luego se especifica el tipo de archivo que debe buscar (esto segun la categoria que escoja el usuario)
  * La funcion guarda estos archivos en una QStringList y luego elimina los archivos que tengan un espacio en su nombre
  * Luego llama a la funcion showfiles
  \param a indica de que tipo es el archivo
  \param text es el parametro por el cual se va a buscar
  */
void Rockola::find(int a,QString text)
{
    QStringList fileName;
    QString path;
    QStringList files;
    if(a==1){
    ui->Lista_Distros->setColumnCount(1);
    ui->Lista_Distros->setRowCount(0);
    ui->Lista_Distros->setColumnWidth(0,256);
    fileName.insert(0,"*.iso");
    path = "/opt/SoLiUNToaster/Distros";
    }

    if(a==2){
    ui->Lista_Musica->setColumnCount(2);
    ui->Lista_Musica->setRowCount(0);
    ui->Lista_Musica->setColumnWidth(0,160);
    ui->Lista_Musica->setColumnWidth(1,70);
    fileName.insert(0,"*");
    path = "/opt/SoLiUNToaster/Musica/";
    path.append(text);
    }

    if(a==3){
    ui->Lista_Imagenes->setColumnCount(2);
    ui->Lista_Imagenes->setRowCount(0);
    ui->Lista_Imagenes->setColumnWidth(0,150);
    ui->Lista_Imagenes->setColumnWidth(1,60);
    fileName.insert(0,"*");
    path = "/opt/SoLiUNToaster/Imagenes/";
    path.append(text);
    }

    if(a==4){
    ui->Lista_Peliculas->setColumnCount(2);
    ui->Lista_Peliculas->setRowCount(0);
    ui->Lista_Peliculas->setColumnWidth(0,150);
    ui->Lista_Peliculas->setColumnWidth(1,60);
    fileName.insert(0,"*.avi");
    path = "/opt/SoLiUNToaster/Peliculas/";
    path.append(text);
    fileName.insert(1,"*.ogv");
    path = "/opt/SoLiUNToaster/Peliculas/";
    path.append(text);
    fileName.insert(2,"*.mkv");
    path = "/opt/SoLiUNToaster/Peliculas/";
    path.append(text);
    fileName.insert(3,"*.mpg");
    path = "/opt/SoLiUNToaster/Peliculas/";
    path.append(text);
    fileName.insert(4,"*.mp4");
    }

    if(a==5){
    ui->Lista_Libros->setColumnCount(2);
    ui->Lista_Libros->setRowCount(0);
    ui->Lista_Libros->setColumnWidth(0,170);
    ui->Lista_Libros->setColumnWidth(1,60);
    fileName.insert(0,"*.pdf");
    path = "/opt/SoLiUNToaster/Peliculas/";
    path.append(text);
    fileName.insert(1,"*.txt");
    path = "/opt/SoLiUNToaster/Libros/";
    path.append(text);
    }

    currentDir = QDir(path);

    if (fileName.isEmpty())
            fileName.insert(0,"*");


    files = currentDir.entryList(QStringList(fileName),
                                 QDir::Files | QDir::NoSymLinks);

    for (int i = files.size()-1; i >= 0; i--) {
            if(files.at(i).contains(" ")||files.at(i).contains("[")||files.at(i).contains("]")||files.at(i).contains("(")||files.at(i).contains(")")||files.at(i).contains("<")||files.at(i).contains(">")){
                files.takeAt(i);
            }
    }

    showFiles(files, a);
}
/*!
   \param files es la lista de archivos a mostrar
   \param b indica de que tipo es el archivo
  * Funcion encargada mostrar los archivos que se encuentran en la QStringlist en el componente indicado segun la categoria en la que se encuentre el usuario
  */
void Rockola::showFiles(const QStringList &files, int b)
{
    int row = 0;
    for (int i = 0; i < files.size(); i++) {
        QFile file(currentDir.absoluteFilePath(files[i]));
        qint64 size = QFileInfo(file).size();
        QString a = QFileInfo(file).owner();
        QTableWidgetItem *won = new QTableWidgetItem(a);
        won->setFlags(won->flags() ^ Qt::ItemIsEditable);

        QTableWidgetItem *fileNameItem = new QTableWidgetItem(files[i]);
        fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
        QTableWidgetItem *sizeItem = new QTableWidgetItem(tr("%1 KB")
                                             .arg(int((size + 1023) / 1024)));
        sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
        sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);

        if(b == 1){
            row = ui->Lista_Distros->rowCount();
            ui->Lista_Distros->insertRow(row);
            ui->Lista_Distros->setItem(row, 0, fileNameItem);

       }
        if(b == 2){
            row = ui->Lista_Musica->rowCount();
            ui->Lista_Musica->insertRow(row);
            ui->Lista_Musica->setItem(row, 0, fileNameItem);
            ui->Lista_Musica->setItem(row, 1, sizeItem);
        }

        if(b == 3){
            row = ui->Lista_Imagenes->rowCount();
            ui->Lista_Imagenes->insertRow(row);
            ui->Lista_Imagenes->setItem(row, 0, fileNameItem);
            ui->Lista_Imagenes->setItem(row, 1, sizeItem);


        }
        if(b == 4){
            row = ui->Lista_Peliculas->rowCount();
            ui->Lista_Peliculas->insertRow(row);
            ui->Lista_Peliculas->setItem(row, 0, fileNameItem);
            ui->Lista_Peliculas->setItem(row, 1, sizeItem);


        }

        if(b == 5){
            row = ui->Lista_Libros->rowCount();
            ui->Lista_Libros->insertRow(row);
            ui->Lista_Libros->setItem(row, 0, fileNameItem);
            ui->Lista_Libros->setItem(row, 1, sizeItem);


        }


    }
}
/*!

  Funcion encargada de de abrir el archivo seleccionado, ademas de llenar la ruta absoluta del archivo para porsteriormente ser usada
  Esta funcion tambien calcula el peso del archivo altual que se usara posteriormente.
  Y obtiene el nombre del archivo de descripcion para las categorias que lo tengan (distribuciones, peliculas, libros)
  Luego llama a la funcion loadfiles
  \param nombre dice el nombre del archivo
    \param carpeta dice en que carpeta se encuentra el archivo
  */
    void Rockola::open(int a, QString nombre,QString carpeta)
{
        superpath="/opt/SoLiUNToaster/";
        QString fileName;
        QString PesoCarpeta;
        if(a==1){
                fileName="Distros/";
                fileName.append(nombre);
                superpath.append(fileName);
                fileName.append(".des");
            }

        if(a==2){
                fileName="Musica/";
                fileName.append(carpeta);
                fileName.append("/");
                PesoCarpeta=superpath;
                PesoCarpeta.append(fileName);
                superPeso=PesoArchivo(PesoCarpeta, nombre);
                fileName.append(nombre);
                superpath.append(fileName);
            }

        if(a==3){
                fileName="Imagenes/";
                fileName.append(carpeta);
                fileName.append("/");
                PesoCarpeta=superpath;
                PesoCarpeta.append(fileName);
                superPeso=PesoArchivo(PesoCarpeta, nombre);
                fileName.append(nombre);
                superpath.append(fileName);
            }

        if(a==4){

                fileName="Peliculas/";
                fileName.append(carpeta);
                fileName.append("/");
                PesoCarpeta=superpath;
                PesoCarpeta.append(fileName);
                superPeso=PesoArchivo(PesoCarpeta, nombre);
                fileName.append(nombre);
                superpath.append(fileName);
                fileName.append(".des");
            }

        if(a==5){
                fileName="Libros/";
                fileName.append(carpeta);
                fileName.append("/");
                PesoCarpeta=superpath;
                PesoCarpeta.append(fileName);
                superPeso=PesoArchivo(PesoCarpeta, nombre);
                fileName.append(nombre);
                superpath.append(fileName);
                fileName.append(".des");
            }

    if (!fileName.isEmpty())
            loadFile(a,fileName);
}

/*!\brief Funcion encargada de abrir los archivos de descripcion
  *
  * Funcion encargada de abrir un archivo con estencion .des que contiene la descripcion del archivo correspondiente (sea distribucion, pelicula o libro)
  * Luego la muestra en el componente de la interfaz que le corresponda segun sea el caso.
  \param b indica de que tipo es el archivo
  \param filename es el nombre del archivo de descripcion
  */
    void Rockola::loadFile(int b,const QString &fileName)
{
    QFile file(fileName);
    if (!file.open(QFile::ReadOnly | QFile::Text)) {
        if(b==1){
            ui->Descripcion_Distro->setPlainText("No se encontro descripcion disponible");
        }
        if(b==4){
            ui->Sinopsis_Pelicula->setPlainText("No se encontro sinopsis disponible");
        }
        if(b==5){
            ui->Resumen_Libro->setPlainText("No se encontro descripcion disponible");
        }
    return;
    }

    QTextStream in(&file);
    QApplication::setOverrideCursor(Qt::WaitCursor);
    if(b==1){
        ui->Descripcion_Distro->setPlainText( in.readAll());
    }
    if(b==4){
        ui->Sinopsis_Pelicula->setPlainText( in.readAll());
    }
    if(b==5){
        ui->Resumen_Libro->setPlainText( in.readAll());
    }

    QApplication::restoreOverrideCursor();

}
/*! \brief Funcion encargada de dar la vistra previa de las imagenes
  *
  * Funcion encargada de abrir la imagen seleccionada por el usuario y mostrarla en un label para generar la vista previa de la misma
  \param nombre dice el nombre del archivo
  \param carpeta indica la ubicacion del archivo
  */
    void Rockola::openImage(QString nombre, QString carpeta)
{

    QString fileName;

    fileName="/opt/SoLiUNToaster/Imagenes/";
                fileName.append(carpeta);
                fileName.append("/");
                fileName.append(nombre);
    if (!fileName.isEmpty()) {
        QImage image(fileName);
        if (image.isNull()) {
            QMessageBox::information(this, tr("Image Viewer"),
                                     tr("No se puede visualizar %1.").arg(fileName));
            return;
        }
         ui->VistaPrevia->setPixmap(QPixmap::fromImage(image));
        double scaleFactor;
        scaleFactor = 1.0;

    }
}
/*!\brief Funcion encargada de limpiar la informacion de las variables globales
  *
  * Funcion encargada de limpiar algunos componentes de la interfas y reinicializar algunas variables globales usadas en el programa.
  */
    void  Rockola::Limpiar(){
superpath="/opt/SoLiUNToaster/";
ListaRutas.clear();
ui->Descripcion_Distro->clear();
ui->Lista_Distros->clear();
ui->Lista_Libros->clear();
ui->Resumen_Libro->clear();
ui->C_Categoria_Libros->setCurrentIndex(0);
ui->Lista_Musica->clear();
ui->C_Musica->setCurrentIndex(0);
ui->Sinopsis_Pelicula->clear();
ui->Lista_Peliculas->clear();
ui->C_Categoria_Peliculas->setCurrentIndex(0);
ui->Lista_Imagenes->clear();
ui->VistaPrevia->clear();
ui->C_Imagenes->setCurrentIndex(0);
}
/*!\brief Funcion Lista Distros
  *
  * Funcion encargada de obtener el nombre de la distribucion que el usuario selecciona haciendo click en la tabla correspondiente.
  * Luego llama a la funcion open pasandole dicho nombre.
  */
void Rockola::on_Lista_Distros_clicked(QModelIndex index)
{
    QListWidgetItem *NombreDistro = new QListWidgetItem;
    NombreDistro->setText( ui->Lista_Distros->currentItem()->text());
    open(1,NombreDistro->text(),"");
}
/*!\brief Funcion Quemar Distros
  *
  * Funcion encargada llamar al escript de quemar distros pasandole la ruta de la iso que debe quemar
  */
void Rockola::on_B_Aceptar_5_clicked()
{
    QString comando = "./quemardistro.sh ";
    comando.append(superpath);
    const char *a = comando.toLatin1();
    int r = system(a);
    if (r!=0){
    QMessageBox::warning(this,"Error!","Se presento un error quemando por favor contacte al administrador");
    }
    else
        QMessageBox::about(this,"Operacion exitosa!","Se a quemado exitosamente. \n GRACIAS POR USAR ESTA APLICACION");
}
/*!\brief Funcion Categoria libros
  *
  * Funcion encargada de elegir el item correspondiente del combobox de libros y pasarselo a la funcion find
  *
  */
void Rockola::on_C_Categoria_Libros_currentIndexChanged(int index)
{
    find(5,ui->C_Categoria_Libros->currentText());
}
/*!\brief Funcion Categoria musica
  *
  * Funcion encargada de elegir el item correspondiente del combobox de musica y pasarselo a la funcion find
  *
  */
void Rockola::on_C_Musica_currentIndexChanged(int index)
{
    find(2,ui->C_Musica->currentText());
}
/*!\brief Funcion Categoria imagenes
  *
  * Funcion encargada de elegir el item correspondiente del combobox de imagenes y pasarselo a la funcion find
  *
  */
void Rockola::on_C_Imagenes_currentIndexChanged(int index)
{
    find(3,ui->C_Imagenes->currentText());
}
/*!\brief Funcion Categoria peliculas
  *
  * Funcion encargada de elegir el item correspondiente del combobox de peliculas y pasarselo a la funcion find
  *
  */
void Rockola::on_C_Categoria_Peliculas_currentIndexChanged(int index)
{
    find(4,ui->C_Categoria_Peliculas->currentText());
}
/*!\brief Funcion Lista Libros
  *
  * Funcion encargada de obtener el item seleccionado por el usuario en la lista de libros y luego pasarselo a find
  *
  */
void Rockola::on_Lista_Libros_clicked(QModelIndex index)
{
QListWidgetItem *NombreLibro = new QListWidgetItem;
    NombreLibro->setText( ui->Lista_Libros->currentItem()->text());
    open(5,NombreLibro->text(),ui->C_Categoria_Libros->currentText());
}
/*!\brief Funcion Lista Peliculas
  *
  * Funcion encargada de obtener el item seleccionado por el usuario en la lista de lpeliculas y luego pasarselo a find
  *
  */
void Rockola::on_Lista_Peliculas_clicked(QModelIndex index)
{
    QListWidgetItem *NombrePelicula = new QListWidgetItem;
    NombrePelicula->setText( ui->Lista_Peliculas->currentItem()->text());
    open(4,NombrePelicula->text(),ui->C_Categoria_Peliculas->currentText());
}
/*!\brief Funcion Lista Imagenes
  *
  * Funcion encargada de obtener el item seleccionado por el usuario en la lista de imagenes y luego pasarselo a find
  *
  */
void Rockola::on_Lista_Imagenes_clicked(QModelIndex index)
{
    QListWidgetItem *NombreImagen = new QListWidgetItem;
    NombreImagen->setText( ui->Lista_Imagenes->currentItem()->text());
    openImage(NombreImagen->text(),ui->C_Imagenes->currentText());
    open(3,NombreImagen->text(),ui->C_Imagenes->currentText());
}
/*!\brief Funcion Varios-Agregar "+"
  *
  * Funcion encargada de agregar el item seleccionado por el usuario en la interfaz varios a la lista de quemar
  * En esta funcion se verifica el peso del item y si es posible agregarlo al contenedor seleccionado (CD o DVD)
  * Agrega este item a la lista para quemar y resta el peso del total disponible
  * Tambien muestra si se presenta algun inconveniente con el item seleccionado por el usuario en un warning
  *
  */
void Rockola::on_B_AgregarMusica_clicked()
{
    int index;
    bool add=false;
    index = ui->stackedVarios->currentIndex();
    QListWidgetItem *item = new QListWidgetItem;
    QMessageBox jojojo;
    if(superPeso<peso && superPeso>0){
        if(index==0){
            if(ui->Lista_Libros->currentColumn()==0){
                item->setText(ui->Lista_Libros->currentItem()->text());
                add = true;
            }
        }
        if(index==1){
            if(ui->Lista_Musica->currentColumn()==0){
                item->setText(ui->Lista_Musica->currentItem()->text());
                add = true;
            }
        }
        if(index==2){
            if(ui->Lista_Imagenes->currentColumn()==0){
                item->setText(ui->Lista_Imagenes->currentItem()->text());
                add = true;
            }
        }
        if(index==3){
            if(ui->Lista_Peliculas->currentColumn()==0){
                item->setText(ui->Lista_Peliculas->currentItem()->text());
                add = true;
            }
        }
        if(add){
            if(!VerificarExiste(superpath)){
            ui->ListaQuemar->addItem(item);
            AgregarItem(superpath);
            AgregarPeso(superPeso);
            peso=peso-superPeso;
            ui->EspacioDisco->setText(QString::number(peso/1024));
        }
            else jojojo.warning(this,"Error","El archivo que intenta agregar ya existe en la lista a quemar \n No ingrese archivos repetidos");
        }
    }else{

        QMessageBox jojojo;
        if(superPeso>0)
            jojojo.warning(this,"Error","El archivo que intenta agregar tiene caracteres invalidos o ya no existe");
        if(superPeso<peso)
            jojojo.warning(this,"Error","El archivo es mas grande que es espacio disponible");
    }
}
/*!\brief Funcion Varios-Borrar "-"
  *
  * Funcion encargada de borrar un item seleccionado por el usuario de la lista para quermar
  * Esta funcion tambien recalcula el peso del dispositivo teniendo en cuenta el peso del archivo que se elimino.
  *
  */
void Rockola::on_B_Borrar_clicked()
{
    if(ui->ListaQuemar->currentRow()>=0){
        QuitarItem(ui->ListaQuemar->currentRow());
    ui->ListaQuemar->currentItem()->~QListWidgetItem();

}
}
/*! \brief Funcion encargada de agregar la ruta del archivo seleccionado
  *
  * Funcion encargada de agregar la ruta absoluta del archivo a un QStringlist
  * en el cual se encuentran las rutas de los archivos ya seleccionados
  \param ruta dice la ruta del archivo

  */
void Rockola::AgregarItem(QString ruta){
ListaRutas.insert(ListaRutas.count(),ruta);
}
/*! \brief Funcion encargada de agregar el peso del archivo seleccionado
  *
  * Funcion encargada de agregar el peso del archivo a un QStringlist
  * en el cual se encuentran los pesos de los archivos ya seleccionados
  \param peso dice el tamaño del archivo que se esta agregando
  */
void Rockola::AgregarPeso(int tamano){
ListaPesos.insert(ListaPesos.count(),QString::number(tamano));
}
/*!\brief Funcion Lista Musica
  *
  * Funcion encargada de seleccionar el item de la lista musica y se lo pasa a la funcion open
  *
  */
void Rockola::on_Lista_Musica_clicked(QModelIndex index)
{
    QListWidgetItem *NombreMusica = new QListWidgetItem;
    NombreMusica->setText( ui->Lista_Musica->currentItem()->text());
    open(2,NombreMusica->text(),ui->C_Musica->currentText());
}
/*!
\brief Funcion encargada de quitar el item seleccionado de la lista de rutas y pesos
  *
  * Funcion encargada de remover un item de la QStringlist de las rutas absolutas y de la de pesos para asi calcular el nuevo peso y mostrarlo
  *
  \param rpos dice la pocicion en la lista de pesos y rutas del archivo a aliminar
  */
void Rockola::QuitarItem(int pos){
    ListaRutas.removeAt(pos);
    QString aux;
    aux = ListaPesos.at(pos);
    superPeso = aux.toInt();
    peso=peso+superPeso;
    ui->EspacioDisco->setText(QString::number(peso/1024));
    ListaPesos.removeAt(pos);

}
/*!\brief Funcion encargada de quemar en la opcion "varios"
  *
  * Funcion encargada de llamar al script de quemar varios contenidos pasandole los parametros correspondientes
  *
  */
void Rockola::on_B_ACEPTAR_clicked()
{
    QTextStream out(stdout);
    QString comando = "./quemarcontenidos.sh ";
    for(int i=0;i<ListaRutas.count();i=i+1){
        comando.append("");
        comando.append(ListaRutas.at(i));
        comando.append(" ");
        //out << comando;
        //out << "/n                     ";
    }
    const char *a = comando.toLatin1();

    int r = system(a);
    if (r!=0){
    QMessageBox::warning(this,"Error!","Se presento un error quemando por favor contacte al administrador");
    }
    else
        QMessageBox::about(this,"Operacion exitosa!","Se a quemado exitosamente. \n GRACIAS POR USAR ESTA APLICACION");
}
/*! \brief Funcion encargada de dar el peso
*
  * Funcion encargada de obtener el peso del archivo indicado
  *
  \param carpeta dice la ruta del archivo
  \param rnombre dice el nombre del archivo
  */
int Rockola::PesoArchivo(QString carpeta, QString nombre)
{
    currentDir = QDir(carpeta);
    QStringList files;
    files = currentDir.entryList(QStringList(nombre), QDir::Files | QDir::NoSymLinks);
    if(files.size()>0){
        QFile file(currentDir.absoluteFilePath(files[0]));
        qint64 size = QFileInfo(file).size();
        int tam=(size + 1023) / 1024;
        return tam;
    }
    return 0;
}
/*!\brief Funcion encargada de ver si el archivo existe
  *
  * Funcion encargada de verificar si el archivo a quemar ya existe en la lista a quemar (en la interfaz varios)
  *
  */
bool Rockola::VerificarExiste(QString pathactual){
    bool existe = false;
for(int j=0;j <  ListaRutas.count();j++){
    if(ListaRutas.at(j)==pathactual)  existe = true;
}
return existe;
}

void Rockola::on_pushButton_clicked()
{
    QMessageBox msgBox;
 msgBox.setText("<h1>Acerca de</h1>");
 msgBox.setInformativeText(tr("<b>SoLiUNToaster v 1.0</b> "
               "<p>Es una aplicacion desarrollada para quemar contenidos abiertos y de dominio publico</p>"
               "<p>Licencia: Licencia Pública General de GNU, versión 2</p>"));
 msgBox.setStandardButtons(QMessageBox::Ok);
 msgBox.setDefaultButton(QMessageBox::Ok);
 msgBox.setDetailedText("Desarrollado por: \n Rene Lobo \n Julian Mahecha \n Diego Montoya");
 msgBox.exec();
}
